{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# भाग 12: एनक्रिप्टेड डेटा पर एनक्रिप्टेड एनएन को प्रशिक्षित करें (Train an Encrypted NN on Encrypted Data)\n",
    "\n",
    "इस नोटबुक में, हम उन सभी तकनीकों का उपयोग करने जा रहे हैं जो हमने अब तक सीखा है न्यूरल नेटवर्क प्रशिक्षण (और भविष्यवाणी) के लिए जबकि मॉडल और डेटा दोनों एन्क्रिप्टेड हो।\n",
    "\n",
    "विशेष रूप से, हम अपने कस्टम Autograd इंजन को प्रस्तुत करते हैं जो एन्क्रिप्टेड संगणना पर काम करता है।\n",
    "\n",
    "लेखक:\n",
    "- Andrew Trask - Twitter: [@iamtrask](https://twitter.com/iamtrask)\n",
    "- Jason Paumier - Github: [@Jasopaum](https://github.com/Jasopaum)\n",
    "- Théo Ryffel - Twitter: [@theoryffel](https://twitter.com/theoryffel)\n",
    "\n",
    "अनुवादक:\n",
    "- Yugandhar Tripathi - Github: [@Yugandhartripathi](https://github.com/Yugandhartripathi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 1: श्रमिक और खिलौना डेटा बनाएँ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import syft as sy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set everything up\n",
    "hook = sy.TorchHook(torch) \n",
    "\n",
    "alice = sy.VirtualWorker(id=\"alice\", hook=hook)\n",
    "bob = sy.VirtualWorker(id=\"bob\", hook=hook)\n",
    "james = sy.VirtualWorker(id=\"james\", hook=hook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A Toy Dataset\n",
    "data = torch.tensor([[0,0],[0,1],[1,0],[1,1.]])\n",
    "target = torch.tensor([[0],[0],[1],[1.]])\n",
    "\n",
    "# A Toy Model\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(2, 2)\n",
    "        self.fc2 = nn.Linear(2, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "model = Net()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 2: मॉडल और डेटा को एन्क्रिप्ट करें\n",
    "\n",
    "यहाँ एन्क्रिप्शन दो चरणों में आता है। चूँकि सिक्योर मल्टी पार्टी कंपटीशन केवल पूर्णांकों पर काम करता है, दशमलव अंकों के साथ संख्याओं को संचालित करने के लिए (जैसे कि वज़न और सक्रियण), हमें अपने सभी नंबरों को निश्चित परिशुद्धता का उपयोग करके सांकेतिक शब्दों में बदलना चाहिए, जो हमें दशमलव परिशुद्धता के कई बिट्स देगा। हम इसे कॉल कर रहे हैं `.fix_precision()`।\n",
    "\n",
    "इसके बाद हम अन्य डेमो की तरह `.share()` कॉल कर सकते हैं, जो ऐलिस और बॉब के बीच साझा करके सभी मूल्यों को एन्क्रिप्ट करेगा। ध्यान दें कि हमने `requires_grad` को `True` भी सेट किया है, जो एन्क्रिप्टेड डेटा के लिए एक विशेष `auto_grad` विधि भी जोड़ता है। दरअसल, चूँकि सिक्योर मल्टी-पार्टी कम्प्यूटेशन फ्लोट वैल्यू पर काम नहीं करता है, इसलिए हम सामान्य PyTorch autograd का उपयोग नहीं कर सकते हैं। इसलिए, हमें एक विशेष `AutogradTensor` नोड को जोड़ने की आवश्यकता है जो backpropagation के लिए ढाल ग्राफ की गणना करता है। आप किसी भी तत्व को यह देखने के लिए प्रिंट कर सकते हैं कि इसमें `AutogradTensor` शामिल है।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We encode everything\n",
    "data = data.fix_precision().share(bob, alice, crypto_provider=james, requires_grad=True)\n",
    "target = target.fix_precision().share(bob, alice, crypto_provider=james, requires_grad=True)\n",
    "model = model.fix_precision().share(bob, alice, crypto_provider=james, requires_grad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# चरण 3: ट्रेन\n",
    "\n",
    "और अब हम साधारण टेंसर लॉजिक का उपयोग करके प्रशिक्षण ले सकते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = optim.SGD(params=model.parameters(),lr=0.1).fix_precision()\n",
    "\n",
    "for iter in range(20):\n",
    "    # 1) erase previous gradients (if they exist)\n",
    "    opt.zero_grad()\n",
    "\n",
    "    # 2) make a prediction\n",
    "    pred = model(data)\n",
    "\n",
    "    # 3) calculate how much we missed\n",
    "    loss = ((pred - target)**2).sum()\n",
    "\n",
    "    # 4) figure out which weights caused us to miss\n",
    "    loss.backward()\n",
    "\n",
    "    # 5) change those weights\n",
    "    opt.step()\n",
    "\n",
    "    # 6) print our progress\n",
    "    print(loss.get().float_precision())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "नुकसान वास्तव में कम हो गया!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "## निश्चित परिशुद्धता का प्रभाव\n",
    "आप आश्चर्यचकित हो सकते हैं कि कैसे सब कुछ एन्क्रिप्ट करने से घटती क्षति प्रभावित होती है। दरअसल, क्योंकि सैद्धांतिक गणना समान है, संख्या गैर-एन्क्रिप्टेड प्रशिक्षण के बहुत करीब है। आप एन्क्रिप्शन के बिना एक ही उदाहरण चलाकर और मॉडल के एक नियतात्मक प्रारंभिककरण के साथ इस तरह का सत्यापन कर सकते हैं जैसे कि मॉडल में `__init__ `:\n",
    "```\n",
    "with torch.no_grad():\n",
    "    self.fc1.weight.set_(torch.tensor([[ 0.0738, -0.2109],[-0.1579,  0.3174]], requires_grad=True))\n",
    "    self.fc1.bias.set_(torch.tensor([0.,0.1], requires_grad=True))\n",
    "    self.fc2.weight.set_(torch.tensor([[-0.5368,  0.7050]], requires_grad=True))\n",
    "    self.fc2.bias.set_(torch.tensor([-0.0343], requires_grad=True))\n",
    "```\n",
    "\n",
    "निश्चित अंतर में परिवर्तित होते समय प्रदर्शन किए गए मानों के गोलाई के कारण आप जो अंतर देख सकते हैं, वह है। डिफ़ॉल्ट `सटीक_ आंशिक` 3 है और यदि आप इसे 2 से नीचे लाते हैं, तो स्पष्ट पाठ प्रशिक्षण बढ़ जाता है, जबकि यह कम कर देता है यदि आप` परिशुद्धता_फैक्शनल = 4` चुनते हैं।"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# बधाई हो!!! - समुदाय में शामिल होने का समय!\n",
    "\n",
    "इस नोटबुक ट्यूटोरियल को पूरा करने पर बधाई! यदि आपने इसका आनंद लिया और एआई और एआई आपूर्ति श्रृंखला (डेटा) के विकेन्द्रीकृत स्वामित्व के संरक्षण, गोपनीयता की ओर आंदोलन में शामिल होना चाहते हैं, तो आप निम्न तरीकों से ऐसा कर सकते हैं!\n",
    "\n",
    "### PySyft को Github पर Star करें!\n",
    "\n",
    "हमारे समुदाय की मदद करने का सबसे आसान तरीका रिपॉजिटरी को अभिनीत करना है! यह हमारे द्वारा बनाए जा रहे कूल टूल्स के बारे में जागरूकता बढ़ाने में मदद करता है।\n",
    "\n",
    "- [स्टार PySyft](https://github.com/OpenMined/PySyft)\n",
    "\n",
    "### हमारे Slack में शामिल हों!\n",
    "\n",
    "नवीनतम प्रगति पर अद्यतित रहने का सबसे अच्छा तरीका हमारे समुदाय में शामिल होना है!\n",
    "\n",
    "- [slack.openmined.org से जुड़ें](http://slack.openmined.org)\n",
    "\n",
    "### एक कोड परियोजना में शामिल हों!\n",
    "\n",
    "हमारे समुदाय में योगदान करने का सबसे अच्छा तरीका एक कोड योगदानकर्ता बनना है! किसी भी समय आप PySyft Github जारी करने वाले पृष्ठ पर जा सकते हैं और \"प्रोजेक्ट्स\" के लिए फ़िल्टर कर सकते हैं। यह आपको सभी शीर्ष स्तर के टिकट दिखाएगा कि आप किन परियोजनाओं में शामिल हो सकते हैं! यदि आप किसी प्रोजेक्ट से जुड़ना नहीं चाहते हैं, लेकिन आप थोड़ी सी कोडिंग करना चाहते हैं, तो आप \"अच्छा पहला अंक\" चिह्नित गिथब मुद्दों की खोज करके अधिक \"वन ऑफ\" मिनी-प्रोजेक्ट्स की तलाश कर सकते हैं।\n",
    "\n",
    "- [PySyft Projects](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3AProject)\n",
    "- [अच्छा पहला अंक टिकट(Good First Issue Tickets)](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+fueue%22)\n",
    "\n",
    "### दान करना\n",
    "\n",
    "यदि आपके पास हमारे कोडबेस में योगदान करने का समय नहीं है, लेकिन फिर भी समर्थन उधार देना चाहते हैं, तो आप हमारे ओपन कलेक्टिव में भी एक बैकर बन सकते हैं। सभी दान हमारी वेब होस्टिंग और अन्य सामुदायिक खर्चों जैसे कि हैकाथॉन और मीटअप की ओर जाते हैं!\n",
    "\n",
    "[OpenMined का ओपन कलेक्टिव पेज](https://opencollective.com/openmined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "hi",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
